#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <functional>

using namespace std;

class A
{
public:
    virtual void f() {}
    int _a = 0;
};

class B : public A
{
public:
    virtual void f()
    {
        cout << "hello , my name is dynamic_cast" << endl;
    }
    int _b = 0;
};
void Func(A *ptr)
{
    // 会成功 —— 但是直接转换是不安全的
    B *bptr = dynamic_cast<B *>(ptr);
    // B* bptr = reinterpret_cast<B*>(ptr);//一样会成功，但是有风险！！！
    cout << bptr << endl;

    bptr->_a++; // 越界问题
    bptr->_b++;

    cout << bptr->_a << endl;
    cout << bptr->_b << endl;
}
int main()
{
    A aa;
    B bb;
    Func(&aa);
    Func(&bb);

    return 0;
}

// void Test()
// {
// 	int i = 1;

// 	// 隐式类型转换
// 	double d = i;//类型相近才能隐式类型转换
// 	printf("%d, %.2f\n", i, d);

// 	int* p = &i;

// 	// 显示的强制类型转换
// 	int address = (int)p;

// 	printf("%x, %d\n", p, address);
// }

// int main()
// {
//     // Test();
//     double a = 10.999;
//     int b = static_cast<int>(a);
//     cout << "a : " << a << " b : " << b << endl;

//     double * c = static_cast<double*>(&a);
//     int* d = reinterpret_cast<int*>(c);
//     cout << "c : " << c << " d : " << d << endl;
//     printf("c : %p d : %zd\n",c,d);

//     volatile const double e = 10.123;
//     double* f = const_cast<double*>(&e);
//     *f +=1;
//     cout << "e : " << e << " f : " << *f << endl;

//     return 0;
// }